Report for doc/examples/arithmetic_2.c

1

//#include <stdio.h>  

2

//#include <stdlib.h>  

3

//#include <assert.h>  

4

5

// Structure to hold division result  

6

//typedef struct {  

7

//   int quotient;  

8

//    int remainder;  

9

//} DivisionResult;  

10

11

// Function prototypes  

12

13

// Arithmetic class implementation  

14

int add(int a, int b) {  

15

    //assert(a >= -100 && a <= 100);  

16

    //assert(b >= -100 && b <= 100);  

17

18

    int i, result;  

19

20

    if (b >= 0) {  

21

        //printf("branch 2\n");  

22

        result = a;  

23

        i = b;  

24

        while (i != 0) {  

25

            result = result + 1;  

26

            i = i - 1;  

27

        }  

28

    } else {  

29

        //printf("branch 3\n");  

30

        result = a;  

31

        i = b;  

32

        while (i != 0) {  

33

            result = result - 1;  

34

            i = i + 1;  

35

        }  

36

    }  

37

    return result;  

38

}  

39

40

int add_recursive(int a, int b) {  

41

    //assert(a >= -100 && a <= 100);  

42

    //assert(b >= -100 && b <= 100);  

43

44

    int result;  

45

    if (b == 0) {  

46

        //printf("branch 4\n");  

47

        result = a;  

48

    } else if (b > 0) {  

49

        //printf("branch 5\n");  

50

        result = add_recursive(a, b - 1) + 1;  

51

    } else {  

52

        //printf("branch 6\n");  

53

        result = add_recursive(a, b + 1) - 1;  

54

    }  

55

    return result;  

56

}  

57

58

int multiply(int a, int b) {  

59

    //assert(a >= -10 && a <= 10);  

60

    //assert(b >= 0 && b <= 10);  

61

    int i, result;  

62

    if (a == 0 || b == 0) {  

63

        //printf("branch 7\n");  

64

        result = 0;  

65

    } else {  

66

        //printf("branch 8\n");  

67

        result = a;  

68

        i = b;  

69

        while (i != 1) {  

70

            result = add(result, a);  

71

            i = i - 1;  

72

        }  

73

    }  

74

    return result;  

75

}  

76

77

int multiply_recursive(int a, int b) {  

78

    //assert(a >= -10 && a <= 10);  

79

    //assert(b >= 0 && b <= 10);  

80

    int result;  

81

82

    if (a == 0 || b == 0) {  

83

        //printf("branch 9\n");  

84

        result = 0;  

85

    } else {  

86

        if (b == 1) {  

87

           // printf("branch 10\n");  

88

            result = a;  

89

        } else {  

90

            //printf("branch 11\n");  

91

            result = add_recursive(a, multiply(a, b - 1));  

92

        }  

93

    }  

94

    return result;  

95

}  

96

97

int divide(int n, int m) {  

98

    //assert(n >= 0);  

99

    //assert(m > 0);  

100

    //assert(n <= 100 && m <= 100);  

101

102

    int q, r;  

103

104

    r = n;  

105

    q = 0;  

106

107

    while (r >= m) {  

108

        //printf("branch 12\n");  

109

        r = add(r, -m);  

110

        q = q + 1;  

111

    }  

112

113

    int result_1 = q;  

114

    int result_2 = r;  

115

	//{q, r};  

116

    return result_1;  

117

}  

118

119

int divide_recursive(int n, int m) {  

120

    //assert(n >= 0);  

121

    //assert(m > 0);  

122

    //assert(n <= 100 && m <= 100);  

123

124

    int result_quotient, result_remainder;  

125

	int res_remainder, res_quotient;  

126

127

    if (n < m) {  

128

        //printf("branch 13\n");  

129

        result_quotient = 0;  

130

        result_remainder = n;  

131

    } else {  

132

        //printf("branch 14\n");  

133

        res_quotient = divide_recursive(add_recursive(n, -m), m);  

134

        result_quotient = res_quotient + 1;  

135

        result_remainder = res_remainder;  

136

    }  

137

138

    return result_quotient;  

139

}  

140

141

// Main function for testing  

142

int main() {      

143

    // Test add  

144

    //printf("Add: %d\n", add(5, 3));  

145

146

    // Test add_recursive  

147

    //printf("Add recursive: %d\n", add_recursive(5, 3));  

148

149

    // Test multiply  

150

    //printf("Multiply: %d\n", multiply(5, 3));  

151

152

    // Test multiply_recursive  

153

    //printf("Multiply recursive: %d\n", multiply_recursive(5, 3));  

154

155

    // Test divide  

156

    //int div_result = divide(10, 3);  

157

    //printf("Divide: quotient = %d, remainder = %d\n", div_result.quotient, div_result.remainder);  

158

159

    // Test divide_recursive  

160

    //int div_result_rec = divide_recursive(10, 3);  

161

    //printf("Divide recursive: quotient = %d, remainder = %d\n", div_result_rec.quotient, div_result_rec.remainder);  

162

163

    int n, m;  

164

    int a, b;  

165

166

	add (a, b);  

167

	add_recursive (a, b);  

168

169

	multiply(a, b);  

170

	multiply_recursive(a, b);  

171

172

    divide (n, m);  

173

	divide_recursive (n, m);  

174

175

    return 0;  

176

}  

177